import conn from "../config/config";
import { useChat } from "../store/chat";
import { useHuihua } from '../store/huihua'
import { useAdmin } from "../store/userInfo";


const getData = () => {
    const fetchHistoryData = (id) => {                  //获取单聊的历史信息
        return new Promise((resolve, reject) => {
            let options = {
                // 对方的用户 ID 或者群组 ID 或聊天室 ID。
                targetId: id,
                // 每页期望获取的消息条数。取值范围为 [1,50]，默认值为 20。
                pageSize: 20,
                // 查询的起始消息 ID。若该参数设置为 `-1`、`null` 或空字符串，从最新消息开始。
                cursor: -1,
                // 会话类型：（默认） `singleChat`：单聊；`groupChat`：群聊。
                // 消息搜索方向：（默认）`up`：按服务器收到消息的时间的逆序获取；`down`：按服务器收到消息的时间的正序获取。
                searchDirection: 'up',
            };
            conn.getHistoryMessages(options)
                .then((res) => {
                    console.log(res);
                    resolve(res);
                })
                .catch((e) => {
                    // 获取失败。
                    reject(e);
                });
        })
    }
    const fetchUserChat = (id = '') => {
        console.log(id);
        setTimeout(() => {
            conn.getServerConversations({ pageSize: 11, cursor: '' }).then((res) => {  //得到当前用户的会话列表
                if (id) {
                    res.data.conversations.forEach(item => {
                        if (item.conversationId == id) {
                            item.unReadCount = 0;
                        }
                    })
                }
                console.log(res);
                getBlackList(res.data);
                console.log(res.data, "异步窗口打开");
            })
        }, 500)
    }

    const getPageUser =(cursor='')=>{
        conn.getServerConversations({ pageSize: 10, cursor}).then((res) => {  //得到当前用户的会话列表
            console.log(res);
        })
    }
    

    const fetchChatToId = (id) => {
        const store = useChat();
        let options = {
            // 对方的用户 ID 或者群组 ID 或聊天室 ID。
            targetId: id,
            // 每页期望获取的消息条数。取值范围为 [1,50]，默认值为 20。
            pageSize: 50,
            // 查询的起始消息 ID。若该参数设置为 `-1`、`null` 或空字符串，从最新消息开始。
            cursor: -1,
            searchDirection: "up",
        };
        conn.getHistoryMessages(options)
            .then((res) => {
                console.log(res);
                store.Chatinfo.value = res;
                yesRead(id)
            })
            .catch((e) => {
                console.log(e);
            });
    }
    const fetchPage = (id,xiaoxi)=>{
        const store = useChat();
        let options = {
            // 对方的用户 ID 或者群组 ID 或聊天室 ID。
            targetId: id,
            // 每页期望获取的消息条数。取值范围为 [1,50]，默认值为 20。
            pageSize: 50,
            // 查询的起始消息 ID。若该参数设置为 `-1`、`null` 或空字符串，从最新消息开始。
            cursor: xiaoxi,
            searchDirection: "up",
        };
        conn.getHistoryMessages(options)
            .then((res) => {
                console.log(res);
                store.Chatinfo.value.messages = store.Chatinfo.value.messages.concat(res.messages);
                store.Chatinfo.value.isLast = res.isLast;
                store.Chatinfo.value.cursor = res.cursor;
                console.log(store.Chatinfo.value);
            })
            .catch((e) => {
                console.log(e);
            });
    }
    const yesRead = (id) => {
        let option = {
            chatType: "singleChat", // 会话类型，设置为单聊。
            type: "channel", // 消息类型。
            to: id, // 接收消息对象的用户 ID。
        };
        let msg = WebIM.message.create(option);
        conn.send(msg);
        fetchUserChat(id);
    }

    const upFile = (uid, text) => {
        let option = {
            // 消息类型。
            type: "txt",
            // 消息内容。
            msg: text,
            // 消息接收方：单聊为对方用户 ID，群聊和聊天室分别为群组 ID 和聊天室 ID。
            to: uid,
            // 会话类型：单聊、群聊和聊天室分别为 `singleChat`、`groupChat` 和 `chatRoom`。
            chatType: "singleChat",
        };
        // 创建文本消息。
        let msg = WebIM.message.create(option);
        console.log(text);
        // 调用 `send` 方法发送该文本消息。
        conn.send(msg).then((res) => {
            const store = useChat();
            const admins = useAdmin();
            store.Chatinfo.value.messages.unshift({
                chatType: "singleChat",
                ext: {},
                from: admins.userinfo.username,
                id: res.serverMsgId,
                msg: text,
                onlineState: 3,
                time: Date.now(),
                to: uid,
                type: "txt"
            })
        }).catch((e) => {
            console.log("Send message fail", e);
        });
    }

    const upImage = (uid,file) => {
        let option = {
            // 消息类型。
            type: "img",
            file: file,
            ext: {
                // 图片文件长度，单位为字节。
                file_length: file.data.size,
            },
            // 消息接收方：单聊为对方用户 ID，群聊和聊天室分别为群组 ID 和聊天室 ID。
            to: uid,
            // 会话类型：单聊、群聊和聊天室分别为 `singleChat`、`groupChat` 和 `chatRoom`。
            chatType: "singleChat",
            // 图片文件上传失败。
            onFileUploadError: function () {
                console.log("onFileUploadError");
            },
            // 图片文件上传进度。
            onFileUploadProgress: function (e) {
                console.log(e);
            },
            // 图片文件上传成功。
            onFileUploadComplete: function () {
                console.log("onFileUploadComplete");
            },
            thumbnailHeight: 200,
            thumbnailWidth: 200,
        };
        console.log(option);
        // 创建一条图片消息。
        let msg = WebIM.message.create(option);
        // 调用 `send` 方法发送该图片消息。
        conn
            .send(msg)
            .then((res) => {
                // 图片文件成功发送。
                console.log("Success",res);
                const store = useChat();
                const admins = useAdmin();
                store.Chatinfo.value.messages.unshift({
                    chatType: "singleChat",
                    ext: {},
                    from: admins.userinfo.username,
                    id: res.serverMsgId,
                    onlineState: 3,
                    time: Date.now(),
                    to: uid,
                    type: "img",
                    url:URL.createObjectURL(file.data)
                })
            })
            .catch((e) => {
                // 图片文件发送失败。
                console.log("Fail");
            });
    }

    const addBlackList = (id)=>{
        conn.addUsersToBlocklist({
            //可以添加单个用户 ID 或批量添加多个用户 ID 组成的数组。
            name: [id], 
        });
        const hui = useHuihua();
        hui.Data = hui.Data.filter(item=>item.conversationId != id)
    }
    const getBlackList = (data)=>{
        const hui = useHuihua();
        conn.getBlocklist().then((res) => {
            hui.BlackList = res.data;
            hui.Data = data.conversations.filter(item=>{
                return !res.data.includes(item.conversationId)
            })
            hui.cursor = data.cursor;
            if(hui.cursor){
                hui.pageId = data.conversations.at(-1).conversationId;
                hui.pageList.push(hui.pageId);
            }
            console.log(hui.latestData);
        });
    }
    return {
        fetchHistoryData,
        fetchChatToId,
        yesRead,
        fetchUserChat,
        upFile,
        upImage,
        addBlackList,
        getBlackList,
        fetchPage,
        getPageUser
    }
}

export default getData;